Meeting Pearls 1

home *** CD-ROM | disk | FTP | other *** search

/ Meeting Pearls 1 / Meeting Pearls Vol 1 (1994).iso / installed_progs / text / faqs / object-faq.part5 < prev next >

Wrap

Internet Message Format | 1993-12-15 | 58.3 KB

Subject: Comp.Object FAQ Version 1.0.5 (12-13) Part 5/8 Newsgroups: comp.object,comp.answers,news.answers From: Bob Hathaway <rjh@geodesic.com> Date: Tue, 14 Dec 1993 04:47:21 GMT Archive-name: object-faq/part5 Last-Modified: 12/13/93 Version: 1.0.5 Workgroup through enterprise-wide and cross-enterprise computing is supported via a distributed client/server architecture that provides a single logical view over multiple databases on heterogeneous machines. The user sees a logical view of objects connected to objects and need not worry that one object is in a database on a Sun workstation, while another may be in a database under Windows or VMS. All operations work transparently across this environment, including atomic transactions with two-phase commit, propagating methods, and versioning. Objects may be moved between databases and platforms without affecting working applications or requiring changes to the applications. Multiple schemas may be created, without affecting other users or databases, and may be used simultaneously with shared schemas, allowing local groups to define their own models but still connect to other groups. Databases may be detached from this shared environment (federated database) and used on portable devices, reconnected or moved to different (compatible) environment, or distributed as parts or image libraries. Gateways to RDBMSs are provided via third-party integration with Persistence Software, and more generally to any foreign data store, as long as the user installs the appropriate access methods, extending the single-logical-view to include read/write access to arbitrary foreign data stores. Together, these allow delegation of responsibilities to the appropriate users, integration with existing systems, and gradual migration toward full enterprise-wide sharing. The on-demand object manager directly and automatically manages object access and buffering, rather than relying on system facilities such as virtual memory or user manual get/put calls. Mechanisms used include multiple buffer pools locally and remotely, b-trees, hashing, scoped names, keys, and iterators, with distributed catalogues for schemas and databases. A direct connection is established between the user and the objects used, so that users do not conflict unless and until they are competing for the same objects, thus avoiding the traditional central-server bottleneck. Short transactions are based on traditional (transient) locks, owned by the process, and group together an arbitrary set of operations. Long transactions are based on persistent locks, owned by the user, and provide the same arbitrary grouping. Default concurrency is two-phase locking and serialization, but extensions available include MROW, or multiple-readers concurrent with one-writer, and allow users to lock with or without wait or with timed waits, to implement more sophisticated mechanisms. Objects may be modeled using C++ structures augmented by classes provided such as strings, dictionaries, and relationship management, as well as some particular domain libraries. A simple object is a C++ class (or C structure) with associated access methods. A complex object may include multiple varrays, each being a dynamically varying sized array of arbitrary structure. A composite object is any network of related objects that acts as a single object, both structurally and behaviorally, via propagation of behaviors to component objects. Any number of composite objects may be contained in composite objects, and a single object may participate in any number of composites. The relationship mechanism supports uni- and bi-directional relationships, one-to-one, one-to-many, and many-to-many. Versioning is supported at object granularity, may be turned on or off at any time for each object, may be restricted to linear or allow branching with multiple writers. References to versioned objects may be to a specific version or to the default version, which may be separately specified by a method and may allow multiple defaults. Schema and object evolution are supported via versioning of the type-defining objects. Each time a type definition is changed, its defining object is versioned, allowing arbitrary changes. Objects may then be instances of the old or new type version. Object evolution or upgrading to the new type version is supported by the user writing conversion methods which are installed and invoked by the system. ANSI SQL query is supported in the SQL++ product. Predicate syntax may be either C++ or SQL. The ODBC and SQL Access Group (SAG) protocols are supported. Queries may be invoked programatically or interactively, with ad hoc support. Access to object features is available via methods and traversal of relationships. Over forty administrative and developer tools are provided, each with both an interactive and programmatic interface. These include GUI object and type browsers, query browsers, report generator, tools to examine and force short and long locks, to move objects and databases, etc. On-line incremental backup provides a consistent network-wide snapshot, including referential integrity across all databases, and runs incremental and full database backups with no need to acquiesce the databases and no interference with active applications. All tools are built around a messaging backplane, which supports four levels of integration with user and third-party tools. Integrated products include HP SoftBench (full operational level), CenterLine's ObjectCenter (tool level), Persistence RDBMS gateway, PTech and ProtoSoft Design and Analysis (language level), and XVT and UIM/X (compatibility level). Objectivity/DB is resold by Digital Equipment Corporation as DEC Object/DB, providing a multi-billion-dollar second source vendor. Over 50,000 end users are licensed in production use, with applications including real-time telecommunications, aerospace, defense, case, CAD/CAM, CIM, manufacturing, oil & gas, process control, transportation, multi-media, case, document management, financial analysis, and corporate information management. Platform support includes all Sun, all DEC (including VMS, alpha, OSF-1), HP/9000 series (both 68xxx and PA-RISC), IBM RS/6000, NCR 3300, SGI, Windows 3.1, and Windows NT. On Schema Evolution (from original survey): In the just-released Version 2.0 (shipping Oct 92), schema evolution is supported via dynamic versioning of type-defining objects [ie. class versions -- SMC], and via a step-by-step approach that allows conversion of instance data via user-provided conversion methods. Also, a full dynamic type manager interface is available for doing fancier things. Contact: Drew Wade Objectivity, Inc. 800 El Camino Real Menlo Park, CA 94025 USA drew@objy.com 1(415)688-8000 voice 1(415)325-0939 fax admin ass't: Vickie Clements (vickie@objy.com) information: info@objy.com > ObjectStore (Object Design) Entry on Schema Evolution only: ObjectStore does not provide schema evolution as yet but it has promised to provide schema evolution in the next release. [h.subramanian@trl.OZ.AU] ObjectStore is an ODBMS produced by Object Design, Inc. Release 2, which is in beta test now, supports schema evolution. The kinds of evolution supported include change of a data member's type, addition and removal of data members, and change in inheritance structure. There are default transformations built in, (e.g. from int to float), and user-defined transformations may be run also. Approximately $5-8K [Ian Schmidt, Object Design, Inc. <schmidt@odi.com>] > Ontos [formerly VBase] (Ontologic) Entry on schema evolution only: *Ontos provides schema evolution. It allows any class to be modified. *The major drawback is that data does not migrate ie., instances are *not modified to adopt to the new class definition. So schema changes *can be done only on classes that do not contain instances and do not *have sub classes that contain instances. *[h.subramanian@trl.OZ.AU] *As a system for experiments, we are currently using ONTOS from *Ontologic Inc. Unfortunately, there is no transparent concept of *schema evolution for populated database. Thus, we still investigate *how it works. ONTOS has a version of ONTOS for OS/2. Approximately $11K. Others I don't know > OpenODB (Hewlett-Packard) OpenODB is an advanced object-oriented database management system (ODBMS) from Hewlett-Packard for your complex commercial application needs. With OpenODB, you can take advantage of new object-oriented features combined with a robust database management system. This combination of capabilities is unique in the industry. OpenODB's object-oriented features will help to reduce your development and maintenance costs by more intuitively representing your business problems. Also, OpenODB stores code as well as data. This means that your application will be simpler and code as well as data can be shared between multiple users and applications. OpenODB's database management features ensure the integrity, security and availability of your stored code and data. At the same time, OpenODB protects your existing data, applications and training investment by allowing you to access existing data and applications using the object-oriented structured query language (OSQL). Hewlett-Packard's OpenODB product uses a client/server architecture, enabling you to efficiently utilize your available computing power. OpenODB's clients use the programmatic interface to access information on the server. OpenODB is composed of the following client and server components: OpenODB Clients o Interactive Object-Oriented SQL (IOSQL) This interface allows you to interactively enter all object- oriented SQL (OSQL) statements, facilitating rapid prototyping and testing. IOSQL provides basic query, administration and editing capabilities. o Graphical Browser The Graphical Browser is a tool that allows you to graphically explore your database schema and contents. This tool is designed to increase the speed of application development by making it easier for you to find reusable code stored in OpenODB. o Programmatic Interface You can write OpenODB applications using any programming language that can be linked with C (C++, COBOL, FORTRAN, Pascal). The programmatic interface uses OSQL statements passed as parameters and does not require preprocessors. o User Applications and Tools These are the OpenODB clients you will develop using IOSQL, the Graphical Browser and the Programmatic Interface. OpenODB Server Components o Object Manager The Object Manager executes OSQL calls made by the OpenODB clients. The Object Manager processes requests and accesses data and code from the internal data storage manager (Relational Storage Manager) or passes the request to a subsystem outside of OpenODB (External Functions). o Relational Storage Manager OpenODB uses a relational database as its storage manager for internally stored data and code. The relational database performs the physical file management and database functions such as multiuser concurrency, transaction management, and recovery. Relational database tools are available to help you perform online backup and recovery, manage physical distribution of files, maximize availability and change database parameters. o External Functions External functions allow you to access data and code stored outside of OpenODB, regardless of data format or location. They are implemented by you as subroutines written in general- purpose programming languages and compiled outside of OpenODB. With external functions, you can encapsulate existing applications. External functions can be called by any OSQL statement, allowing you to use this remote data and application code like any other object. OpenODB Object Model In OpenODB, the object-oriented model is based upon three components: objects, types and functions. These terms are defined as follows in OpenODB: Objects are a combination of data and stored code that operate on the data. Types allow you to classify similar objects. Functions operate on data in the database and also define the behavior of that data in the database. OpenODB supports the following three types of user-defined functions: * Stored functions define attributes and relationships that are stored in the database. * OSQL-based functions define attributes and relationships that are retrieved or calculated with OSQL statements. * External functions are a reference to code or data stored outside of OpenODB. OpenODB Language You create and manipulate objects, types and functions using OpenODB's object-oriented structured query language (OSQL). OSQL is a functional language that is a semantic superset of SQL, the structured query language used for relational databases. OSQL is a complete language with statements that allow you to define and manipulate your OpenODB database, specify authorization by individuals or groups, define transactions, embed program logic within functions, and administer your database. Using OSQL, you can create the following schema: +---------------+ Type | Employee | Name, Salary, Picture, +---------------+ SalaryDeduction, WorksFor, +----------------|----------------+ DisplayPicture +----------------+ +-----------------+ Subtype | Manager | Manages | Programmer | Languages +----------------+ +-----------------+ OpenODB Schema Diagram Creating Types and Functions The first step is to create basic types and functions using the CREATE TYPE statement, and to create additional functions using the CREATE FUNCTION statement. Next, using the simple OSQL statements shown in Table 2, you can create specific objects. Create a user-defined type called Employee with three stored functions: CREATE TYPE Employee FUNCTIONS (Name CHAR, Salary FLOAT, Picture BINARY); Create type Programmer, a subtype of Employee. Also define the stored function Languages on Programmer: CREATE TYPE Programmer SUBTYPE OF Employee FUNCTIONS (Languages SETTYPE(CHAR)); Create type Manager, a subtype of Employee. Also define the stored function Manages on Manager: CREATE TYPE Manager SUBTYPE OF Employee FUNCTIONS (Manages SETTYPE(Employee)); Create an OSQL-based function SalaryDeduction on Employee: CREATE FUNCTION SalaryDeduction (Employee e) -> FLOAT AS OSQL SELECT (0.3 * Salary (e)); Create an OSQL-based function WorksFor on Employee to define the relationship with Manager: CREATE FUNCTION WorksFor (Employee e) -> Manager AS OSQL SELECT mgr FOR EACH Manager mgr WHERE e IN Manages(mgr); Create an external function on Employee to display the employee's picture: CREATE FUNCTION DisplayPicture (CHAR Name) -> CHAR AS EXTERNAL SIMPLEEXTFUN('DisplayPicture $Name'); Creating Objects Put data into three stored functions defined on the Programmer type: CREATE OBJECT AS Programmer FUNCTIONS (Name, Salary, Languages) :bob ('Bob Cox', 55000, SET('PL/1', 'C')), :sue ('Sue Smith', 65000, SET('COBOL')); Put data into three stored functions defined on the Manager type: CREATE OBJECT AS Manager FUNCTIONS (Name, Salary, Manages) :al ('Al Ott', 70000, SET(:bob,:sue)), :jim ('Jim Hill', 100000, SET()); Put data into three stored functions using a reference to another object: CREATE OBJECT AS Manager FUNCTIONS (Name, Salary, Manages) :chris ('Chris Jones', 80000, SET(:al,:jim)); SQL-like Queries Select Bob's salary: SELECT Salary (:bob); Result: 55000 Select the names of the employees that Al manages: SELECT Name(Manages(:al)); Results: 'Bob Cox' 'Sue Smith' Select the names of all managers: SELECT Name (m) FOR EACH Manager m; Results: 'Al Ott' 'Jim Hill' 'Chris Jones' NOTE: The ":" denotes a temporary variable (e.g. :bob) defined in your application to store a reference to your OpenODB object. Development of New Applications Faster Using OpenODB, you can directly model your business information in an intuitive way. You can also reuse code stored in OpenODB to reduce your application backlog and improve your productivity. To help you develop new applications faster, OpenODB provides the following features: Object Identity Each object stored in OpenODB has a system-provided, unique handle called an object identifier (OID). OIDs reduce duplication of information and relieve you from creating unique keys to identify stored information in the database. Complex Objects With OpenODB you can construct complex objects from simpler objects. Complex objects relieve your application code from managing the relationships between simple objects. Referential Integrity Since OpenODB has knowledge of the relationships between objects, it can manage referential integrity on your behalf. That is, if objects referenced by other objects are deleted, the system removes all dependencies. You can specify whether or not to "cascade" changes or to just delete the immediate dependency. For instance, if you delete the Employee 'Bob Cox', the function call (Name(Manages(:al))) will return just 'Sue Smith'. The result is a simplified database schema and simplified application code that can be developed more quickly since you do not need to manage referential integrity explicitly. User-defined Data Types In addition to the primitive data types you can construct user-defined data types in OpenODB rather than in your application code. User-defined types give you more flexibility and lead to more manageable, clearer code. Type Hierarchy Types can be organized in a hierarchy. This hierarchy of types and related functions allows you to minimize the translation from your business model to your OpenODB schema. The hierarchy also enables a type to inherit functions defined on "parents", eliminating duplication of functions. You will be able to more quickly move from application design to implementation. Multiple Inheritance Functions defined on a type can be inherited by one or more subtypes. By inheriting rather than redefining functions, you can easily extend the functionality of your application. Overloaded Functions Multiple functions can have the same name with different implementations. In your application, all you need to do is call a function (e.g. Salary). OpenODB will determine which code (Salary for Employee or Salary for Manager) to execute based upon the parameter passed at run-time. As a result, your application code is simplified since the logic for determining which function to execute is now in OpenODB. Late Binding OpenODB supports functions that are resolved at run-time. Late binding allows you more flexibility in application development and gives you the full power of overloaded functions as described above. Late binding also shields your applications from changes to functions since these changes can be made online and the new function definition resolved at run-time. Reduced Maintenance Costs OpenODB allows you to add new functionality and make schema changes to your OpenODB database at run-time, often without changing your application code or even stopping the database system. The following OpenODB features will help reduce your maintenance costs: Dynamic Schema Modification You can create new functions and types in OpenODB at runtime. You can also change the implementation of functions without having to recompile your applications. Dynamic Typing You can dynamically change the type of an object without having to destroy and recreate the object. This is possible because an object can belong to more that one type. Encapsulation OpenODB supports the combination of data and user-defined functions. Since OpenODB only allows access to your data through these functions, your application is protected from changes to the function implementation and you have control over how users access information in OpenODB. Encapsulation allows you to modify the function body without changing your application code. Procedural Language OSQL includes programming flow statements, including IF/THEN/ELSE, FOR and WHILE. The procedural language allows OpenODB functions to be quite complex, simplifying your application code. By moving application code into the database, you can now share the code and get all of the benefits of sharing data, such as consistency, security and integrity. For example... Create a Procedure Convert all managers to programmers that have less than a specified number of employees: CREATE FUNCTION MgrToEng (INTEGER minemps) -> BOOLEAN AS OSQL BEGIN FOR m IN Manager DO IF (COUNT(Manager (m)) < minemps) THEN BEGIN ADD TYPE Programmer TO m; REMOVE TYPE Manager FROM m; END ENDIF; END; Executing a Procedure Applications are simplified since the implementation of functions can now be stored in OpenODB. Simply call a function, passing a parameter: CALL MgrToEng(3); Protection of Existing Investments OpenODB coexists with your current data and applications, allowing you to build upon existing functionality. Also, OpenODB's object-oriented SQL (OSQL) is easy to learn if you already know Structured Query Language (SQL). External Functions Using external functions, you can access distributed data and code stored outside of OpenODB, regardless of data format or location. This simplified view of your enterprise allows you to more easily develop complex applications that integrate your existing data and applications. For instance, you can develop an OpenODB application that accesses data stored in other databases (e.g. ALLBASE/SQL, TurboImage or DB2) as well as in flat files. OpenODB acts as an integrator so that your application just needs to know OSQL. OSQL statements may actually call functions that access data and encapsulate code stored outside of OpenODB. OSQL If you already know SQL, you can quickly be productive using OpenODB's OSQL. OSQL uses syntax that is similar to SQL, the semantics are a superset of SQL, and both query languages are set-based, that is they retrieve sets of information based upon queries, as shown in earlier examples. Optimize Performance and Availability OpenODB, with the help of the underlying relational storage manager, gives you flexibility in managing the performance of your system and maximizing the availability of information for your users. High Availability OpenODB maximizes the availability of your information by providing: * dual logging, to ensure the integrity of your log file * switch log, to automatically switch to a second log file if the original log file is damaged or becomes full * dynamic file expansion, to automatically expand the size of your system file if it becomes full * online backup of the database, to backup the database while it is being accessed OpenODB will also take advantage of available system features such as disc mirroring. Multiuser Concurrency Control OpenODB is designed to support hundreds of users accessing the same information while guaranteeing the integrity of that information. Compiled Functions To improve runtime performance, functions are compiled and can be cached. Access Methods on Stored Data Indexes are automatically defined on object identifiers (OIDs) for you when you create types and functions. These indexes help provide quick access to information stored in your OpenODB ODBMS. You can also define your own indexes. Clustering Related functions can be stored close to each other in order to improve performance. Additional Features Authorization You can control access to OpenODB at the database and function levels based on individuals or a group of users. Authorization statements provide you a flexible way to control access to types and functions in OpenODB. Client/Server Architecture Clients communicate with the OpenODB server over a network. The interface between the clients and the server is transparent to you as a user. The clients and server can also reside on the same machine. Multimedia OpenODB allows you to store large, unformatted data in binary format. Some examples include graphics, images or voice. You can also define functions in OpenODB to manipulate this multimedia information. For example, you can store a picture as well as the function to display the picture. Native Language Support You can store 8-bit and 16-bit character data in OpenODB. Persistent Data and Code OpenODB allows you to save data as well as code between application sessions. Primitive Data Types OpenODB supports a number of primitive data types, shown in the OpenODB Feature Summary below. You can also create your own user-defined data types. Recovery OpenODB has a robust logging and recovery facility. In case of a failure, OpenODB can handle rollback or rollforward recovery to a particular time, using your log file to recreate saved work. Transaction Management OpenODB ensures the logical and physical integrity of your database by giving you complete control over the unit of work to be performed within a single transaction. With this control, you can save or rollback a transaction (throw away temporary work) at your discretion. Savepoints are supported so that you can rollback parts of a transaction. System Environment The OpenODB server and all clients are available on HP-UX 8.0 or later versions for the HP9000 Series 300/400/700/800 systems and for MPE XL 4.0 or later versions for the HP3000 Series 900 systems. Client software will also be supported using X terminals. You will need 16 Mbytes of main memory (32 Mbytes recommended), at least 15 Mbytes disc space for installation and approximately 10 Mbytes DISC space for each new OpenODB database. Software Requirements To use OpenODB, you need to have a TCP/IP transport and ARPA Berkeley Services. To use the OpenODB Graphical Browser, you need to have X-Window X11. Ordering Information The software includes: OpenODB clients (IOSQL, Graphical Browser, Programmatic Interface) and the 1-8 user license for the OpenODB server (Object Manager, Runtime ALLBASE/SQL and External Functions). You must specify a media option for the HP9000 systems. Product Number Product Description B2466A OpenODB Developer Release for HP9000 S300/S400 B2468A OpenODB Developer Release for HP9000 S700 B2470A OpenODB Developer Release for HP9000 S800 B2472A OpenODB Developer Release for HP3000 S900 Documentation, Online Support, Training and Consulting The OpenODB Developer Release includes documentation for all systems. The OpenODB Developer Release also includes online support, training and consulting. These services will be arranged when you place an order for the product. OBJECT-ORIENTED FEATURES CLIENT INTERFACES Complex Objects Interactive OSQL Dynamic Schema Modification Graphical Browser Dynamic Typing Programmatic Interfaces: C Encapsulation linkable languages (C++, External Functions COBOL, FORTRAN, Pascal) Functions (Stored Code or Methods) Late Binding OSQL STATEMENTS Multiple Inheritance Add/Remove Type To/From Object Object Identity (OID) Add/Remove User Overloaded Functions Call Function Type (Class) Hierarchy Change Password User-defined Data Types Create/Delete Function Create/Delete Object DBMS FEATURES Create/Delete Type Access Methods on Stored Data Create/Delete User/Group Authorization (Security) Grant/Revoke Client/Server If/Then/Else, While, For Clustering Implement Function Compiled Function Open/Fetch/Close Cursor Declarative Query Language (OSQL) Select High Availability Update Multimedia Multiuser Concurrency Control PRIMITIVE DATA TYPES Native Language Support Binary Persistence Boolean Primitive Data Types Character Procedural Language Date Recovery Datetime Referential Integrity Decimal Transaction Management Floating Point Integer Interval Long Binary (Large) Small Integer Time OpenODB Feature Summary HP OpenODB Price Guide SUMMARY: Description U.S. List Price 1. Developer's Bundle $105,000 2. Evaluator's Bundle $5,000 3. Learning Version $10,000 4. Training Course $2,500/person 5. Consulting $3,500/day or Quote 6. Reference Manual $250 DETAILED DESCRIPTION: 1. Developer's Bundle Contents: A) OpenODB software (1-64 User License for 1 Server Platform) B) OpenODB documentation C) 5 passes to the OpenODB Training Course D) 5 days of on-site consulting E) Phone and software update support for 6 months U.S. List Price: $105,000/bundle Product Numbers: B2472A (for HP 3000 Series 900 with MPE/iX) B2468A (for HP 9000 Series 700 with HP-UX) B2470A (for HP 9000 Series 800 with HP-UX) Notes: A) OpenODB documentation includes the OpenODB Reference Manual, ALLBASE/SQL Handbook of DBA Tasks, and Up and Running with ALLBASE/SQL. B) The OpenODB Training Course is delivered in Cupertino, California and takes 4 days. C) Consulting is provided at the customer's site with a maximum of two trips. D) Phone support is provided directly from the HP OpenODB factory consulting team in Cupertino, California. Phone and software update support can be purchased at the end of the first 6 months at the rate of $6,900 per year. E) Volume End User (VEU) and Educational discounts apply to the entire list price. F) The Developer's Bundle is available on HP 3000 Series 900 or HP 9000 Series 700 and 800 computers. 2. Evaluator's Bundle Contents: A) 3 months use of OpenODB software (1-64 User License for 1 Server Platform) B) OpenODB documentation C) 1 pass to the OpenODB Training Course D) Phone support for 3 months U.S. List Price: $5,000/bundle Product Numbers: B3178A (for HP 9000 Series 700 with HP-UX) B3179A (for HP 9000 Series 800 with HP-UX) Notes: A) The OpenODB software is shipped when the product is ordered. The OpenODB software will stop running 3 months after it is installed. B) OpenODB documentation includes the OpenODB Reference Manual, ALLBASE/SQL Handbook of DBA Tasks, and Up and Running with ALLBASE/SQL. C) The OpenODB Training Course is delivered in Cupertino, California and takes 4 days. D) Phone support is provided directly from the HP OpenODB factory consulting team in Cupertino, California. E) Volume End User and Educational discounts apply to the entire list price. F) The Evaluator's Bundle is only available on HP 9000 Series 700 or 800 computers. 3. Learning Version Contents: A) OpenODB learning version software (Single User License for 1 Platform) B) OpenODB documentation U.S. List Price: $10,000/license Product Numbers: B3181A (for HP 9000 Series 700 with HP-UX) B3182A (for HP 9000 Series 800 with HP-UX) Notes: A) This special single user version is intended for students, researchers, and technical evaluators who wish to learn about the Object-oriented SQL (OSQL) interface language and OpenODB product. The learning version software runs on one computer for one user application (i.e. no client/server mode). B) OpenODB documentation includes the OpenODB Reference Manual, ALLBASE/SQL Handbook of DBA Tasks, and Up and Running with ALLBASE/SQL. C) Volume End User and Educational discounts apply to the list price. D) The Learning Version is available on HP 9000 Series 700 and 800 computers. E) Phone and software update support for the Learning Version can be purchased at the rate of $1,500 per year. 4. OpenODB Training Course Contents: A) 1 pass to the OpenODB Training Course B) OpenODB documentation C) Class notes and OSQL case study examples U.S. List Price: $2,500/person Product Number: B3184A Notes: A) The OpenODB Training Course is delivered in Cupertino, California and takes 4 days. B) OpenODB documentation includes the OpenODB Reference Manual, ALLBASE/SQL Handbook of DBA Tasks, and Up and Running with ALLBASE/SQL. C) The OpenODB Training Course includes hands on experience with the OpenODB software through a case study approach. D) No standard discounts apply. 5. OpenODB Consulting Contents: A) 1 person on the customer's site for technical consulting U.S. List Price: $3,500/day + zone charge/trip Product Number: B3186A Notes: A) For details about this consulting, see the OpenODB Consulting Fact Sheet. B) The zone charges per trip are: $1000 in North America, $2000 in Europe, and $3000 in the Far East and South America. Consulting that does not require travel will not have a zone charge. C) Special quotes are available for projects longer than one week. D) No standard discounts apply. 6. OpenODB Reference Manual Contents: A) OpenODB Reference Manual B) The right to make up to 5 additional copies of the OpenODB Reference Manual for internal use only. U.S. List Price: $250/manual & right to copy Product Number: B3185A Notes: A) No standard discounts apply Mark Boronkay OpenODB Consultant boronkay@cup.hp.com > POET <Persistent Objects and Extended Database Technology> (BKS Software) C++ Language Support o tight semantic integration with C++ o any C++ object or structure can be made persistent by adding the persistent keyword o storing and reading a C++ object does not change its state or behavior o full support for C++ encapsulation, object identity, inheritance, and polymorphy o C++ pointers and references are automatically converted to database references when storing objects o database references are automatically converted to C++ pointers and references when reading objects o all database definition is done through a small extension to C++ declaration syntax Database Functionality navigation, queries, sorting, indexes, single-user operation, multi-user operation using client/server architecture, flexible locking for objects and sets, nested transactions, watch & notify for objects and sets, event handling, database size limited only by hard disk size C++ Language Extensions persistence, indexes, transient data elements in persistent classes, sets, dependent objects PTXX-Precompiler automatically converts extended C++ class declarations into ANSI 2.0 code, registers classes in the class dictionary, provides class versioning Predefined C++ Classes date, time, strings, and BLOBS (binary large objects) Portability all platforms are source-code compatible, any POET database may be read by any computer full support for heterogeneous networks Platforms Available for MS-DOS / MS-Windows (Borland C++, Microsoft), OS/2 (Borland C++), Novell, Macintosh MPW, and various Unix systems, including NeXT (NeXTStep) and Sun OS (Sun C++). How to Contact Us: BKS has offices in Santa Clara, Hamburg, and Berlin. Silicon River, Limited, is responsible for POET in the United Kingdom. Santa Clara: (North America, Australia, Asia) BKS Software 4633 Old Ironsides Drive Suite 110 Santa Clara, CA 95054 Phone: 408 / 748 - 3403 Fax: 408 / 748 - 9060 Contact Person: jrobie@netmbx.netmbx.de (Jonathan Robie) > Statice (Symbolics) From: fischerm@darmstadt.gmd.de (Markus Fischer) Newsgroups: comp.databases.object,comp.lang.lisp Subject: Statice now runs on Unix Date: 15 Jun 93 14:55:48 GMT Hi there, since I've never seen 'Symbolics' or 'Statice' in comp.database.object, this might be interesting: A few days ago, Symbolics announced the availability of a beta- release of their ODBMS 'Statice' on Unix platforms. It is quite powerful and tightly integrated within Common Lisp. Currently, Symbolics and LUCID are supported. People (like me) used to Symbolics' Genera development environment can continue to use Statice there (where it has been already successfully employed in 'real world' applications) and now also use it on Unix Workstations. (Those are the cheaper boxes, I guess). Both kinds of platforms can be freely intermixed in a network. Statice is based on standards of Lisp: CLOS and CLIM (Common Lisp Object System, resp. Common Lisp Interface Manager) Here's the address of Symbolics in Germany; they're mostly responsible for Statice on Unix: Symbolics Systemhaus GmbH Mergenthalerallee 77 6236 Eschborn (til June 31) 65760 Eschborn (from July 1) Tel. (49) 6196-47220, Fax (49) 6196-481116 Contact person is Dr. Thomas Neumann (TN@symbolics.de). Also: "Update Database Schema" brings an existing database into conformance with a modified schema. Changes are classified as either compatible (lossless, i.e., completely information-preserving) or incompatible (i.e., potentially information-losing in the current implementation). Basically, any change is compatible except for the following: -- If an attribute's type changes, all such attributes extant are re-initialized (nulled out). Note that Statice permits an attribute to be of type T, the universal type. Such an attribute can then take on any value without schema modification or information loss. -- If a type's inheritance (list of parents) changes, the type must be deleted and re-created, losing all extant instances of that type. This is Statice's most serious current limitation. The simplest workaround is to employ a database dumper/loader (either the one supplied by Symbolics or a customized one) to save the information elements and then reload them into the modified schema. [Lawrence G Mayka <lgm@IExist.ATT.COM>] > UniSQL UniSQL offers a state-of-the-art suite of integrated object-oriented database systems and application development products which can be used separately or together to support complex development projects which use object-oriented development techniques, integrate sophisticated multimedia data, and require true multidatabase access to relational and object-oriented databases. The UniSQL product suite includes: UniSQL/X Database Management System; UniSQL/M Multidatabase System; and UniSQL/4GE Application Development Environment User interfaces include: C++, C, Object SQL, SmallTalk, and ODBC Database interfaces include: Ingres, Oracle, Sybase, UniSQL/X, and EDA/SQL UniSQL offers: - A wide selection of user interfaces including C++, SmallTalk, C, Microsoft's ODBC, both embedded (static and dynamic) and interactive Object SQL, and UniSQL and 3rd-party development tools. - Mission-critical database features such as a high-level query language (SQL/X), cost-based query optimization, automatic transaction management, automatic concurrency control, dynamic schema evolution, dynamic authorization, physical disk structuring options, and installation tuning parameters. - The UniSQL Multimedia Framework which provides natural and uniform database system support for all types of large unstructured data objects. The Multimedia Framework also provides for seamless integration of multimedia devices such as fax machines, CD jukeboxes, satellite feeds, image compression boards, etc. - The UniSQL/M Multidatabase System enables developers to manage a collection of multi-vendor databases -- Ingres, Oracle, Sybase, DB2, UniSQL/X, and others -- as a single federated database system with full object-oriented capabilities. UniSQL has well over 150 customers around the world, the majority of which are using UniSQL database products for mission-critical applications which require object-oriented, multimedia, post-relational, and heterogeneous database capabilities. A typical UniSQL customer is a Fortune 500 company, a commercial software developer, or government organization that is using UniSQL database products to: - support mission-critical application development projects which are being developed using object-oriented programming languages and development techniques, - support applications which must integrate many different types of corporate data -- text and documents, tabular data, images and audio, engineering drawings, GIS data, procedural data (programs), etc. -- into a single application context. - support the full object-oriented development paradigm using existing relational database systems such as Ingres, Oracle, Sybase, and DB2. - logically integrate one or more relational and object-oriented databases to form a single, homogenized database server which supports both relational and object-oriented facilities. In September 1992, UniSQL was selected by the Petrotechnical Open Software Corporation (POSC) -- over more than 25 other industry vendors -- to provide database technology which is being used by POSC in their development of a new data management specification for the oil & gas industry. Also during 1992, because of its powerful multimedia capabilities, UniSQL was selected by the MIT AthenaMuse Consortium on multimedia as the consortium's multimedia database system. During the DB/EXPO '93 Conference and Exhibition, UniSQL was chosen in competition with major industry database vendors as a finalist in the ``RealWare Awards''. The ``RealWare Awards'' honor companies that have had a major impact in the user community. UniSQL was founded in May 1990 by Dr. Won Kim, President and CEO, delivering the UniSQL/X DBMS in March of 1992. With its world-class database research and architectural team, UniSQL has perfected what the database industry has sought since the mid-1980s: a fully object-oriented data model that is a natural conceptual outgrowth of the popular relational model. Both the UniSQL/X DBMS and the UniSQL/M Multidatabase System represent the first of a powerful new generation of client-server database systems that support the full object-oriented paradigm yet retain all of the strengths and capabilities of relational database systems including support for ANSI-standard SQL. UniSQL currently has 45 employees and is privately owned and managed by Dr. Kim. The company has secured long-term funding from NTT Data Communications Systems Corp. (NTT Data), a $2 billion company, which is Japan's foremost systems integrator and UniSQL's exclusive distributor in Japan. For more information, contact: UniSQL, Inc. 9390 Research Blvd., II-200 Austin, Texas 78759-6544 Tel.: 512/343-7297 Tollfree: 800/451-DBMS Fax.: 512/343-7383 And: From: jonh@unisql.UUCP (Jon Higby) Newsgroups: comp.databases,comp.databases.theory,comp.databases.object,comp.object Subject: Re: SQL3, Itasca, & UniSQL/X Message-ID: <6143@unisql.UUCP> Date: 10 Sep 93 14:26:04 GMT References: <CD1Ln5.9G3@dcs.glasgow.ac.uk> Organization: UniSQL, Inc., Austin, Texas, USA >>... For UniSQL/X, feel free to contact me (email, snail-mail or phone). UniSQL/X is a SQL compliant database with Object Oriented extensions (classes, inheritance, methods, etc). We have an information packet available which includes a white-paper on our OORDMS approach. Jon Higby Technical Services Consultant UniSQL, Inc. 9390 Research II, Suite 200 Austin, Texas 78759-6544 (512) 343-7297 ***************************************************************************** Standard disclaimer ... All opinions expressed are my own and not of my employer....................................... ***************************************************************************** > Versant (Versant Object Technology) Versant is a client/server object database management system (ODBMS) targeted at distributed, multi-user applications. Versant runs on UNIX and PC platforms, including Sun, IBM, HP, DEC, SGI, Sequent, OS/2, with support for Windows NT is planned during 1993. Versant provides transparent language interfaces from object-oriented programming languages such as C++ and Smalltalk. Versant also supports a C API. Versant is built with an object-level architecture, which means that operations are generally performed on the object (or group thereof) level. Key Versant features include: Performance ----------- * Object-level locking for fine granularity concurrency control * Server-based query processing to reduce network I/O * Dual caching to speed warm traversals * Dynamic space reclamation and reuse Distribution ------------ * Immutable, logical object identifiers for data integrity * Object migration (transparent relocation across nodes) * Transparent cross-node references (distributed db) * Automatic two-phase commit Other ----- * Schema evolution (online via lazy updates) * Standard workgroup features (e.g., versioning, checkin/out) * Detachable, personal databases * DBA utilities Additional information available from info@versant.com (General information) davek@versant.com (Dave Kellogg) Versant Object Technology 1380 Willow Road Menlo Park, California 94025 415-329-7500 phone. 415-325-2380 fax. On Schema Evolution (from original survey): We support run-time schema evolution. It uses a lazy scheme, so schema operations are very fast. Objects on disk may have an older `storage class' and they will be updated to the new schema when they are used. In older releases schema evolution was allowed only on leaf classes (those with no subclasses). In our new release 2 (going to beta test soon) you can do schema evolution on any class. In the future we're working on more general view mechanisms so you can see a subset of the attributes in memory, or some more complicated transformation. This goes together with support for multiple compilers and multiple languages. [Joe Keane <osc!jgk@amd.com>] Also: 1-800-Versant Other Models ------------ Research Systems ________________ > GRAS -------------------------------------------------------------- GRAS - A Graph-Oriented Database System for SE Applications Copyright (C) 1987-1993 Lehrstuhl Informatik III, RWTH Aachen -------------------------------------------------------------- See the GNU Library General Public License for copyright details. Contact Adresses: Dr. Andy Schuerr Lehrstuhl fuer Informatik III, University of Technology Aachen (RWTH Aachen), Ahornstr. 55, D-5100 Aachen Email to andy@i3.informatik.rwth-aachen.de GRAS is a database system which has been designed according to the requirements resulting from software engineering applications. Software development environments are composed of tools which operate on complex, highly structured data. In order to model such data in a natural way, we have selected attributed graphs as GRAS' underlying data model. A first prototype of the GRAS (GRAph Storage) system - described in /BL 85/ - was already realized in 1985. Since this time gradually improving versions of the system have been used at different sites within the software engineering projects IPSEN /Na 90/, Rigi /MK 88/, MERLIN /DG 90/, and CADDY /EHH 89/. Based on these experiences, almost all parts of the original prototype have been redesigned and reimplemented. Thus, nowadays a stable and efficiently working single-process version of the system GRAS with interfaces for the programming languages Modula-2 and C is available as free software for Sun workstations (the GRAS system itself is implemented in Modula-2 and consists of many layers which might be reusable for the implementation of other systems): Via anonymous ftp from ftp.informatik.rwth-aachen.de in directory /pub/unix/GRAS in file gras.<version-no>.tar.Z. There are several files containing documentation, sources, binaries, application examples, and libraries. All binaries are for Sun/4 machines. Sun/3 binaries are shipped only if explicitly requested. You have to use the following sequence of operations for installing the GRAS system at your site: 1) 'ftp ftp.informatik.rwth-aachen.de' (with login name "anonymous" and password equal to your mail address). 2) 'cd pub/unix/GRAS' (for changing the current directory). 3) 'binary' (command for changing ftp mode). 4) 'get gras.<version-no.>' (use 'ls' for finding the currently used GRAS version nr.). 5) 'bye' (for exiting ftp). 6) 'uncompress gras.<version-no>.tar'. 7) 'tar xvf gras.<version-no>.tar' (creates a subdirectory GRAS_2 for the Modula-2 implementation of GRAS including its C-interface). 8) Follow the instructions in file GRAS_2/README. The current version has programming interfaces for Modula-2 and C and supports: - the manipulation of persistent attributed, directed node- and edge-labeled graphs (including the creation of very long attributes and of attribute indexes). - the manipulation of temporary/volatile generic sets/relations/lists, - the coordination of graph accesses by different GRAS applications (multiple-read/single-write access with graphs as lock units), - error recovery based on shadow pages and forward logs, - nested transactions and linear undo/redo of arbitrarily long sequences of already committed graph modifying operations based on forward and backward logs, - event-handling (with certain kinds of graph-modifications as events and graph-modifying transactions as event-handlers), - primitives for version control comprising the capability for efficiently storing graphs as forward/backward deltas to other graphs, - and primitives for declaring graph schemes and for incremental evaluation of derived attributes. Furthermore, tools for (un-)compressing graphs and a X11R5-based graph browser are part of this release. A multi-process version of the system GRAS supporting the inter- action of multiple client and multiple server processes within one local area network is nearby completion (version 6.0/0). Thus, the GRAS system may be considered to be the core of a graph oriented DBMS environment. The development of such an environment based on a very high-level specifications language named PROGRES is under way (the underlying calculus of this specifcation language are so-called PROgrammed GRaph REwriting Systems). This environment will comprise the following tools (a prerelease of this environment might be made available upon request): - a syntax-directed editor for graph schemes, graph rewrite rules, and sequences of graph rewrite rules, - an incrementally working consistency checker, - an incrementally working compiler&interpreter translating PROGRES specifications into sequences of GRAS procedure calls (for C as well as for Modula-2), - and an "enhanced" graph (scheme) browser. References ---------- Refer to the following publications for further info about GRAS, PROGRES, and related topics: /BL85/ Brandes, Lewerentz: A Non-Standard Data Base System within a Software Development Environment. In Proc. of the Workshop on Software Engineering Environments for Programming-in-the- Large, pp 113-121, Cape Cod, June 1985 /DHKPRS90/ Dewal, Hormann, Kelter, Platz, Roschewski, Schoepe: Evaluation of Object Management Systems. Memorandum 44, University Dortmund, March 1990 /Feye92/ Feye A.: Compilation of Path Expressions (in German), Diploma Thesis, RWTH Aachen (1992) /Hoefer92/ Hoefer F.: Incremental Attribute Evaluation for Graphs (in German), Diploma Thesis, RWTH Aachen (1992) /HPRS90/ Hormann, Platz, Roschweski, Schoepe: The Hypermodel Benchmark, Description, Execution and Results. Memorandum 53, University Dortmund, September 1990 /KSW92/ * Kiesel, Schuerr, Westfechtel: GRAS, A Graph-Oriented Database System for (Software) Engineering Applications. Proc. CASE 93, Lee, Reid, Jarzabek (eds.): Proc. CASE '93, 6th Int. Conf. on Computer-Aided Software Engineering, IEEE Computer Society Press (1993), pp 272-286 Also: Technical Report AIB 92-44, /Klein92/ Klein P.: The PROGRES Graph Code Machine (in German), Diploma Thesis, RWTH Aachen (1992) /Kossing92/ Kossing P.: Modelling of Abstract Syntax Graphs for normalized EBNFs (in German), Diploma Thesis, RWTH Aachen (1992) /LS88/ Lewerentz, Schuerr: GRAS, a Management System for Graph- Like Documents. In Proceedings of the Third International Conference on Data and Knowledge Bases, Morgan Kaufmann Publ. Inc. (1988), pp 19-31 /Nagl89/ Nagl (ed.): Proc. WG'89 Workshop on Graphtheoretic Concepts in Computer Science, LNCS 411, Springer-Verlag (1989) /NS91/ Nagl, Schuerr: A Specification Environment for Graph Grammars, in Proc. 4th Int. Workshop on Graph-Grammars and Their Application to Computer Science, LNCS 532, Springer- Verlag 1991, pp 599-609 /Schuerr89/ Schuerr: Introduction to PROGRES, an Attribute Graph Grammar Based Specification Language, in: /Nagl89/, pp 151-165 /Schuerr91a/ * Schuerr: PROGRES: A VHL-Language Based on Graph Grammars, in Proc. 4th Int. Workshop on Graph-Grammars and Their Application to Computer Science, LNCS 532, Springer- Verlag 1991, pp 641-659 Also: Technical Report AIB 90-16 /Schuerr91b/ Schuerr: Operational Specifications with Programmed Graph Rewriting Systems: Theory, Tools, and Applications, Dissertation, Deutscher Universitaetsverlag (1991) (in German) /SZ91/ * Schuerr, Zuendorf: Nondeterministic Control Structures for Graph Rewriting Systems, in Proc. WG'91 Workshop in Graph- theoretic Concepts in Computer Science, LNCS 570, Springer- Verlag 1992, pp 48-62 Also: Technical Report AIB 91-17 /Westfe89/ Westfechtel: Extension of a Graph Storage for Software Documents with Primitives for Undo/Redo and Revision Control. Technical Report AIB Nr. 89-8, Aachen University of Technology, 1989 /Westfe91/ Westfechtel: Revisionskontrolle in einer integrierten Soft- wareentwicklungsumgebung, Dissertation, RWTH Aachen, 1991 /Zuendorf89/ Zuendorf: Kontrollstrukturen fuer die Spezifikationssprache PROGRES, Diplomarbeit, RWTH Aachen, 1989 /Zuendorf92/ * Zuendorf A.: Implementation of the Imperative/Rule Based Language PROGRES, Technical Report AIB 92-38, RWTH Aachen, Germany (1992) /Zuendorf93/ * Zuendorf A.: A Heuristic Solution for the (Sub-) Graph Isomorphism Problem in Executing PROGRES, Technical Report AIB 93-5, RWTH Aachen, Germany (1993) * : All reports marked with an asterisk are available via anonymous ftp from ftp.informatik.rwth-aachen.de in directory /pub/reports/... . See also PROGRES documentation. [See also APPENDIX E] > IRIS (HP Labs) [Iris is a system out of HP Labs that began as a prototype and eventually became a commercial product. I believe it was eventually incorporated into the new HP product, OpenODB. - clamen] Long and short system summaries can be found in: [FISH89] D.H. Fishman et. al. Overview of the Iris DBMS. In Won. Kim and Frederick H. Lochovsky, editors, Object-Oriented Concepts, Databases and Applications, chapter 10, pages 219--250. Addison-Wesley, Reading, MA, 1989. [FBC+87] D.H. Fishman, D. Beech, H.P. Cate, E.C. Chow, T. Connors, J.W. Davis, N. Derrett, C.G. Hock, W. Kent, P. Lyngbaek, B. Mahbod, M.A. Neimat, T.A. Tyan, and M.C. Shan. Iris: An object-oriented database management system. ACM Transactions on Office Information Systems, 5(1):48--69, January 1987. The abstract of the latter (written early in the project) follows: The Iris database management system is a research prototype of a next-generation database management system intended to meet the needs of new and emerging database applications, including office automation and knowledge-based systems, engineering test and measurement, and hardware and software design. Iris is exploring a rich set of new database capabilities required by these applications, including rich data-modeling constructs, direct database support for inference, novel and extensible data types, for example to support graphic images, voice, text, vectors, and matrices, support for long transactions spanning minutes to many days, and multiple versions of data. These capabilities are, in addition to the usual support for permanence of data, controlled sharing, backup and recovery. The Iris DBMS consists of (1) a query processor that implements the Iris object-oriented data model, (2) a Relational Storage Subsystem (RSS) -like storage manager that provides access paths and concurrency control, backup and recovery, and (3) a collection of programmatic and interactive interfaces. The data model supports high-level structural abstractions, such as classification, generalization, and aggregation, as well as behavioral abstractions. The interfaces to Iris include an object-oriented extension to SQL. On Schema Evolution (from original survey): Objects in the Iris system may acquire or lose types dynamically. Thus, if an object no longer matches a changed definition, the user can choose to remove the type from the object instead of modifying the object to match the type. In general, Iris tends to restrict class modifications so that object modifications are not necessary. For example, a class cannot be removed unless it has no instances and new supertype-subtype relationships cannot be established.